{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pix2Pix实现图像转换\n",
    "\n",
    "## Pix2Pix概述\n",
    "\n",
    "Pix2Pix是基于条件生成对抗网络（cGAN, Condition Generative Adversarial Networks ）实现的一种深度学习图像转换模型，该模型是由Phillip Isola等作者在2017年CVPR上提出的，可以实现语义/标签到真实图片、灰度图到彩色图、航空图到地图、白天到黑夜、线稿图到实物图的转换。Pix2Pix是将cGAN应用于有监督的图像到图像翻译的经典之作，其包括两个模型：**生成器**和**判别器**。\n",
    "\n",
    "传统上，尽管此类任务的目标都是相同的从像素预测像素，但每项都是用单独的专用机器来处理的。而Pix2Pix使用的网络作为一个通用框架，使用相同的架构和目标，只在不同的数据上进行训练，即可得到令人满意的结果，鉴于此许多人已经使用此网络发布了他们自己的艺术作品。\n",
    "\n",
    "## 基础原理\n",
    "\n",
    "cGAN的生成器与传统GAN的生成器在原理上有一些区别，cGAN的生成器是将输入图片作为指导信息，由输入图像不断尝试生成用于迷惑判别器的“假”图像，由输入图像转换输出为相应“假”图像的本质是从像素到另一个像素的映射，而传统GAN的生成器是基于一个给定的随机噪声生成图像，输出图像通过其他约束条件控制生成，这是cGAN和GAN的在图像翻译任务中的差异。Pix2Pix中判别器的任务是判断从生成器输出的图像是真实的训练图像还是生成的“假”图像。在生成器与判别器的不断博弈过程中，模型会达到一个平衡点，生成器输出的图像与真实训练数据使得判别器刚好具有50%的概率判断正确。\n",
    "\n",
    "在案例开始前，首先定义一些在整个过程中需要用到的符号：\n",
    "\n",
    "- $x$：代表观测图像的数据。\n",
    "- $z$：代表随机噪声的数据。\n",
    "- $y=G(x,z)$：生成器网络，给出由观测图像$x$与随机噪声$z$生成的“假”图片，其中$x$来自于训练数据而非生成器。\n",
    "- $D(x,G(x,z))$：判别器网络，给出图像判定为真实图像的概率，其中$x$来自于训练数据，$G(x,z)$来自于生成器。\n",
    "\n",
    "cGAN的目标可以表示为：\n",
    "\n",
    "$$L_{cGAN}(G,D)=E_{(x,y)}[log(D(x,y))]+E_{(x,z)}[log(1-D(x,G(x,z)))]$$\n",
    "\n",
    "该公式是cGAN的损失函数，`D`想要尽最大努力去正确分类真实图像与“假”图像，也就是使参数$log D(x,y)$最大化；而`G`则尽最大努力用生成的“假”图像$y$欺骗`D`，避免被识破，也就是使参数$log(1−D(G(x,z)))$最小化。cGAN的目标可简化为：\n",
    "\n",
    "$$arg\\min_{G}\\max_{D}L_{cGAN}(G,D)$$\n",
    "\n",
    "![pix2pix1](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0/tutorials/application/source_zh_cn/generative/images/pix2pix_1.png)\n",
    "\n",
    "为了对比cGAN和GAN的不同，我们将GAN的目标也进行了说明：\n",
    "\n",
    "$$L_{GAN}(G,D)=E_{y}[log(D(y))]+E_{(x,z)}[log(1-D(x,z))]$$\n",
    "\n",
    "从公式可以看出，GAN直接由随机噪声$z$生成“假”图像，不借助观测图像$x$的任何信息。过去的经验告诉我们，GAN与传统损失混合使用是有好处的，判别器的任务不变，依旧是区分真实图像与“假”图像，但是生成器的任务不仅要欺骗判别器，还要在传统损失的基础上接近训练数据。假设cGAN与L1正则化混合使用，那么有:\n",
    "\n",
    "$$L_{L1}(G)=E_{(x,y,z)}[||y-G(x,z)||_{1}]$$\n",
    "\n",
    "进而得到最终目标：\n",
    "\n",
    "$$arg\\min_{G}\\max_{D}L_{cGAN}(G,D)+\\lambda L_{L1}(G)$$\n",
    "\n",
    "图像转换问题本质上其实就是像素到像素的映射问题，Pix2Pix使用完全一样的网络结构和目标函数，仅更换不同的训练数据集就能分别实现以上的任务。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置运行环境\n",
    "\n",
    "由于资源限制，需开启性能优化模式，具体设置如下参数：\n",
    "\n",
    " max_device_memory=\"2GB\" : 设置设备可用的最大内存为2GB。\n",
    "\n",
    " mode=mindspore.GRAPH_MODE : 表示在GRAPH_MODE模式中运行。\n",
    "\n",
    " device_target=\"Ascend\" : 表示待运行的目标设备为Ascend。\n",
    "\n",
    " jit_config={\"jit_level\":\"O2\"} : 编译优化级别开启极致性能优化，使用下沉的执行方式。\n",
    "\n",
    " ascend_config={\"precision_mode\":\"allow_mix_precision\"} : 自动混合精度，自动将部分算子的精度降低到float16或bfloat16。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore\n",
    "mindspore.set_context(max_device_memory=\"2GB\", mode=mindspore.GRAPH_MODE, device_target=\"Ascend\",  jit_config={\"jit_level\":\"O2\"}, ascend_config={\"precision_mode\":\"allow_mix_precision\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建网络\n",
    "\n",
    "当处理完数据后，就可以来进行网络的搭建了。网络搭建将逐一详细讨论生成器、判别器和损失函数。生成器G用到的是U-Net结构，输入的轮廓图$x$编码再解码成真是图片，判别器D用到的是作者自己提出来的条件判别器PatchGAN，判别器D的作用是在轮廓图 $x$的条件下，对于生成的图片$G(x)$判断为假，对于真实判断为真。\n",
    "\n",
    "### 生成器G结构\n",
    "\n",
    "U-Net是德国Freiburg大学模式识别和图像处理组提出的一种全卷积结构。它分为两个部分，其中左侧是由卷积和降采样操作组成的压缩路径，右侧是由卷积和上采样组成的扩张路径，扩张的每个网络块的输入由上一层上采样的特征和压缩路径部分的特征拼接而成。网络模型整体是一个U形的结构，因此被叫做U-Net。和常见的先降采样到低维度，再升采样到原始分辨率的编解码结构的网络相比，U-Net的区别是加入skip-connection，对应的feature maps和decode之后的同样大小的feature maps按通道拼一起，用来保留不同分辨率下像素级的细节信息。\n",
    "\n",
    "![pix2pix2](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0/tutorials/application/source_zh_cn/generative/images/pix2pix_2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 定义UNet Skip Connection Block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/miniconda3/lib/python3.9/site-packages/numpy/core/getlimits.py:499: UserWarning: The value of the smallest subnormal for <class 'numpy.float64'> type is zero.\n",
      "  setattr(self, word, getattr(machar, word).flat[0])\n",
      "/usr/local/miniconda3/lib/python3.9/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for <class 'numpy.float64'> type is zero.\n",
      "  return self._float_to_str(self.smallest_subnormal)\n",
      "/usr/local/miniconda3/lib/python3.9/site-packages/numpy/core/getlimits.py:499: UserWarning: The value of the smallest subnormal for <class 'numpy.float32'> type is zero.\n",
      "  setattr(self, word, getattr(machar, word).flat[0])\n",
      "/usr/local/miniconda3/lib/python3.9/site-packages/numpy/core/getlimits.py:89: UserWarning: The value of the smallest subnormal for <class 'numpy.float32'> type is zero.\n",
      "  return self._float_to_str(self.smallest_subnormal)\n"
     ]
    }
   ],
   "source": [
    "import mindspore.nn as nn\n",
    "import mindspore.ops as ops\n",
    "\n",
    "import time\n",
    "\n",
    "a1 = time.time()\n",
    "\n",
    "class UNetSkipConnectionBlock(nn.Cell):\n",
    "    def __init__(self, outer_nc, inner_nc, in_planes=None, dropout=False,\n",
    "                 submodule=None, outermost=False, innermost=False, alpha=0.2, norm_mode='batch'):\n",
    "        super(UNetSkipConnectionBlock, self).__init__()\n",
    "        down_norm = nn.BatchNorm2d(inner_nc)\n",
    "        up_norm = nn.BatchNorm2d(outer_nc)\n",
    "        use_bias = False\n",
    "        if norm_mode == 'instance':\n",
    "            down_norm = nn.BatchNorm2d(inner_nc, affine=False)\n",
    "            up_norm = nn.BatchNorm2d(outer_nc, affine=False)\n",
    "            use_bias = True\n",
    "        if in_planes is None:\n",
    "            in_planes = outer_nc\n",
    "        down_conv = nn.Conv2d(in_planes, inner_nc, kernel_size=4,\n",
    "                              stride=2, padding=1, has_bias=use_bias, pad_mode='pad')\n",
    "        down_relu = nn.LeakyReLU(alpha)\n",
    "        up_relu = nn.ReLU()\n",
    "        if outermost:\n",
    "            up_conv = nn.Conv2dTranspose(inner_nc * 2, outer_nc,\n",
    "                                         kernel_size=4, stride=2,\n",
    "                                         padding=1, pad_mode='pad')\n",
    "            down = [down_conv]\n",
    "            up = [up_relu, up_conv, nn.Tanh()]\n",
    "            model = down + [submodule] + up\n",
    "        elif innermost:\n",
    "            up_conv = nn.Conv2dTranspose(inner_nc, outer_nc,\n",
    "                                         kernel_size=4, stride=2,\n",
    "                                         padding=1, has_bias=use_bias, pad_mode='pad')\n",
    "            down = [down_relu, down_conv]\n",
    "            up = [up_relu, up_conv, up_norm]\n",
    "            model = down + up\n",
    "        else:\n",
    "            up_conv = nn.Conv2dTranspose(inner_nc * 2, outer_nc,\n",
    "                                         kernel_size=4, stride=2,\n",
    "                                         padding=1, has_bias=use_bias, pad_mode='pad')\n",
    "            down = [down_relu, down_conv, down_norm]\n",
    "            up = [up_relu, up_conv, up_norm]\n",
    "\n",
    "            model = down + [submodule] + up\n",
    "            if dropout:\n",
    "                model.append(nn.Dropout(p=0.5))\n",
    "        self.model = nn.SequentialCell(model)\n",
    "        self.skip_connections = not outermost\n",
    "\n",
    "    def construct(self, x):\n",
    "        out = self.model(x)\n",
    "        if self.skip_connections:\n",
    "            out = ops.concat((out, x), axis=1)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 基于UNet的生成器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UNetGenerator(nn.Cell):\n",
    "    def __init__(self, in_planes, out_planes, ngf=64, n_layers=8, norm_mode='bn', dropout=False):\n",
    "        super(UNetGenerator, self).__init__()\n",
    "        unet_block = UNetSkipConnectionBlock(ngf * 8, ngf * 8, in_planes=None, submodule=None,\n",
    "                                             norm_mode=norm_mode, innermost=True)\n",
    "        for _ in range(n_layers - 5):\n",
    "            unet_block = UNetSkipConnectionBlock(ngf * 8, ngf * 8, in_planes=None, submodule=unet_block,\n",
    "                                                 norm_mode=norm_mode, dropout=dropout)\n",
    "        unet_block = UNetSkipConnectionBlock(ngf * 4, ngf * 8, in_planes=None, submodule=unet_block,\n",
    "                                             norm_mode=norm_mode)\n",
    "        unet_block = UNetSkipConnectionBlock(ngf * 2, ngf * 4, in_planes=None, submodule=unet_block,\n",
    "                                             norm_mode=norm_mode)\n",
    "        unet_block = UNetSkipConnectionBlock(ngf, ngf * 2, in_planes=None, submodule=unet_block,\n",
    "                                             norm_mode=norm_mode)\n",
    "        self.model = UNetSkipConnectionBlock(out_planes, ngf, in_planes=in_planes, submodule=unet_block,\n",
    "                                             outermost=True, norm_mode=norm_mode)\n",
    "\n",
    "    def construct(self, x):\n",
    "        return self.model(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "原始cGAN的输入是条件x和噪声z两种信息，这里的生成器只使用了条件信息，因此不能生成多样性的结果。因此Pix2Pix在训练和测试时都使用了dropout，这样可以生成多样性的结果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 基于PatchGAN的判别器\n",
    "\n",
    "判别器使用的PatchGAN结构，可看做卷积。生成的矩阵中的每个点代表原图的一小块区域（patch）。通过矩阵中的各个值来判断原图中对应每个Patch的真假。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.nn as nn\n",
    "\n",
    "class ConvNormRelu(nn.Cell):\n",
    "    def __init__(self,\n",
    "                 in_planes,\n",
    "                 out_planes,\n",
    "                 kernel_size=4,\n",
    "                 stride=2,\n",
    "                 alpha=0.2,\n",
    "                 norm_mode='batch',\n",
    "                 pad_mode='CONSTANT',\n",
    "                 use_relu=True,\n",
    "                 padding=None):\n",
    "        super(ConvNormRelu, self).__init__()\n",
    "        norm = nn.BatchNorm2d(out_planes)\n",
    "        if norm_mode == 'instance':\n",
    "            norm = nn.BatchNorm2d(out_planes, affine=False)\n",
    "        has_bias = (norm_mode == 'instance')\n",
    "        if not padding:\n",
    "            padding = (kernel_size - 1) // 2\n",
    "        if pad_mode == 'CONSTANT':\n",
    "            conv = nn.Conv2d(in_planes, out_planes, kernel_size, stride, pad_mode='pad',\n",
    "                             has_bias=has_bias, padding=padding)\n",
    "            layers = [conv, norm]\n",
    "        else:\n",
    "            paddings = ((0, 0), (0, 0), (padding, padding), (padding, padding))\n",
    "            pad = nn.Pad(paddings=paddings, mode=pad_mode)\n",
    "            conv = nn.Conv2d(in_planes, out_planes, kernel_size, stride, pad_mode='pad', has_bias=has_bias)\n",
    "            layers = [pad, conv, norm]\n",
    "        if use_relu:\n",
    "            relu = nn.ReLU()\n",
    "            if alpha > 0:\n",
    "                relu = nn.LeakyReLU(alpha)\n",
    "            layers.append(relu)\n",
    "        self.features = nn.SequentialCell(layers)\n",
    "\n",
    "    def construct(self, x):\n",
    "        output = self.features(x)\n",
    "        return output\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pix2Pix的生成器初始化\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.nn as nn\n",
    "from mindspore.common import initializer as init\n",
    "\n",
    "g_in_planes = 3\n",
    "g_out_planes = 3\n",
    "g_ngf = 64\n",
    "g_layers = 8\n",
    "d_in_planes = 6\n",
    "d_ndf = 64\n",
    "d_layers = 3\n",
    "alpha = 0.2\n",
    "init_gain = 0.02\n",
    "init_type = 'normal'\n",
    "\n",
    "\n",
    "net_generator = UNetGenerator(in_planes=g_in_planes, out_planes=g_out_planes,\n",
    "                              ngf=g_ngf, n_layers=g_layers)\n",
    "\n",
    "for _, cell in net_generator.cells_and_names():\n",
    "    if isinstance(cell, (nn.Conv2d, nn.Conv2dTranspose)):\n",
    "        if init_type == 'normal':\n",
    "            cell.weight.set_data(init.initializer(init.Normal(init_gain), cell.weight.shape))\n",
    "        elif init_type == 'xavier':\n",
    "            cell.weight.set_data(init.initializer(init.XavierUniform(init_gain), cell.weight.shape))\n",
    "        elif init_type == 'constant':\n",
    "            cell.weight.set_data(init.initializer(0.001, cell.weight.shape))\n",
    "        else:\n",
    "            raise NotImplementedError('initialization method [%s] is not implemented' % init_type)\n",
    "    elif isinstance(cell, nn.BatchNorm2d):\n",
    "        cell.gamma.set_data(init.initializer('ones', cell.gamma.shape))\n",
    "        cell.beta.set_data(init.initializer('zeros', cell.beta.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 准备环节\n",
    "\n",
    "### 准备数据\n",
    "\n",
    "在本案例中，我们将使用[指定数据集](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/models/application/dataset_pix2pix.tar)，该数据集是已经经过处理的外墙（facades）数据，可以直接使用mindspore.dataset的方法读取。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating data folder...\n",
      "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/models/application/dataset_pix2pix.tar (840.0 MB)\n",
      "\n",
      "file_sizes: 100%|████████████████████████████| 881M/881M [02:29<00:00, 5.88MB/s]\n",
      "Extracting tar file...\n",
      "Successfully downloaded / unzipped to ./dataset\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'./dataset'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from download import download\n",
    "\n",
    "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/models/application/dataset_pix2pix.tar\"\n",
    "\n",
    "download(url, \"./dataset\", kind=\"tar\", replace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据展示\n",
    "\n",
    "调用`Pix2PixDataset`和`create_train_dataset`读取训练集，这里我们直接下载已经处理好的数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x420 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mindspore import dataset as ds\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "dataset = ds.MindDataset(\"./dataset/dataset_pix2pix/train.mindrecord\", columns_list=[\"input_images\", \"target_images\"], shuffle=True)\n",
    "data_iter = next(dataset.create_dict_iterator(output_numpy=True))\n",
    "# 可视化部分训练数据\n",
    "plt.figure(figsize=(10, 3), dpi=140)\n",
    "for i, image in enumerate(data_iter['input_images'][:10], 1):\n",
    "    plt.subplot(3, 10, i)\n",
    "    plt.axis(\"off\")\n",
    "    plt.imshow((image.transpose(1, 2, 0) + 1) / 2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 推理\n",
    "\n",
    "通过load_checkpoint和load_param_into_net将ckpt中的权重参数导入到模型中，获取数据进行推理并对推理的效果图进行演示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mindspore import load_checkpoint, load_param_into_net\n",
    "\n",
    "# download ckpt\n",
    "pix2pix_url = \"https://modelers.cn/coderepo/web/v1/file/MindSpore-Lab/cluoud_obs/main/media/examples/mindspore-courses/orange-pi-online-infer/11-Pix2Pix/ckptGenerator_100.ckpt\"\n",
    "path = \"./ckptGenerator_100.ckpt\"\n",
    "ckpt_path = download(pix2pix_url, path, replace=True)\n",
    "\n",
    "param_g = load_checkpoint(ckpt_path)\n",
    "load_param_into_net(net_generator, param_g)\n",
    "dataset = ds.MindDataset(\"./dataset/dataset_pix2pix/train.mindrecord\", columns_list=[\"input_images\", \"target_images\"], shuffle=True)\n",
    "data_iter = next(dataset.create_dict_iterator())\n",
    "predict_show = net_generator(data_iter[\"input_images\"])\n",
    "plt.figure(figsize=(10, 3), dpi=140)\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 10, i + 1)\n",
    "    plt.imshow((data_iter[\"input_images\"][i].asnumpy().transpose(1, 2, 0) + 1) / 2)\n",
    "    plt.axis(\"off\")\n",
    "    plt.subplots_adjust(wspace=0.05, hspace=0.02)\n",
    "    plt.subplot(2, 10, i + 11)\n",
    "    plt.imshow((predict_show[i].asnumpy().transpose(1, 2, 0) + 1) / 2)\n",
    "    plt.axis(\"off\")\n",
    "    plt.subplots_adjust(wspace=0.05, hspace=0.02)\n",
    "plt.show()\n",
    "\n",
    "a2 = time.time()\n",
    "\n",
    "print(\"time: \", a2 -a1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "各数据集分别推理的效果如下"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![pix2pix3](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0/tutorials/application/source_zh_cn/generative/images/pix2pix_3.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
